package com.itany.stream;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author:石小俊
 * @Date:2022/11/17 15:23
 * @Version:1.0-SNAPSHOT
 * @Description:
 */
public class Test03 {
    private static List<Integer> list = Arrays.asList(1,4,6,9,15,18,22,11,12,13);
//    private static List<Integer> list = new ArrayList<>();

    public static void main(String[] args) {
//        allMatchTest();
//        anyMatchTest();
//        noneMatchTest();
//        findFirstTest();
//        findAnyTest();
//        countTest();
//        maxTest();
//        minTest();
//        reduceTest();
        collectTest();
    }

    public static void allMatchTest(){
        // 判断当前集合中是否所有数据均为偶数
        boolean flag = list.stream()
                .allMatch(e -> e % 2 == 0);
        System.out.println(flag);
    }

    public static void anyMatchTest(){
        // 判断当前集合中是否包含偶数
        boolean flag = list.stream()
                .anyMatch(e -> e % 2 == 0);
        System.out.println(flag);
    }

    public static void noneMatchTest(){
        boolean flag = list.stream()
                .noneMatch(e -> e > 20);
        System.out.println(flag);
    }

    public static void findFirstTest(){
        // 获取第一个元素,存放到Optional对象中
        Optional<Integer> optional = list.stream().findFirst();
        // 可以从该对象中获取对应的元素
        if(optional.isPresent()){
            // 表示有值
            Integer num = optional.get();
            System.out.println(num);
        } else{
            // 表示没值
            // 如果没有值,可以设置一个默认值
            Integer num = optional.orElse(-1);
            System.out.println(num);
        }
    }

    public static void findAnyTest(){
        // 获取随机一个元素
        // 对于stream而言,始终获取第一个元素
        // 对于并发流parallelStream,会随机获取
        Optional<Integer> any = list.parallelStream().findAny();
        System.out.println(any.get());
    }


    // 计数,返回流中元素总数
    public static void countTest(){
        System.out.println(list.stream().count());
    }

    // 取最大值
    public static void maxTest(){
        Optional<Integer> max = list.stream().max((a, b) -> a - b);
        System.out.println(max.get());
    }

    // 取最小值
    public static void minTest(){
        Optional<Integer> min = list.stream().min((a, b) -> a - b);
        System.out.println(min.get());
    }

    // 归约
    // 将元素中所有的值通过一定的规则变成一个数据
    public static void reduceTest(){
//        Optional<Integer> reduce = list.stream().reduce((a, b) -> a + b);
//        System.out.println(reduce.get());

        // 求和操作
        Optional<Integer> reduce = Stream.iterate(1, i -> i + 1)
                .limit(10)
//                .reduce((a, b) -> a + b);
                .reduce(Integer::sum);
        System.out.println(reduce.get());
    }

    public static void collectTest(){
        // 取出指定集合中所有的偶数,生成另一个List集合
        List<Integer> collect = list.stream()
                .filter(i -> i % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(collect);
        // 转换成Set集合
        Set<Integer> set = list.stream()
                .filter(i -> i % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
}